home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / network.swg / 0013_Novell IPX functions.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1994-05-26  |  50.7 KB  |  1,178 lines
  1. UNIT IPX;
  2. (****************************************************************************)
  3. (*                                                                          *)
  4. (*  PROJEKT        : PASCAL Treiber fuer Novell-NetWare                     *)
  5. (*  MODULE         : IPX.PAS                                                *)
  6. (*  VERSION        : 1.10C                                                  *)
  7. (*  COMPILER       : Turbo Pascal V 6.0                                     *)
  8. (*  DATUM          : 13.06.91                                               *)
  9. (*  AUTOR          : R. Gilomen                                             *)
  10. (*  GEPRUEFT       : R. Gilomen                                             *)
  11. (*                                                                          *)
  12. (*--------------------------------------------------------------------------*)
  13. (*                                                                          *)
  14. (*  BESCHREIBUNG   : Bibliothek mit den IPX-Grunfunktionen. Dieses Modul    *)
  15. (*                   wurde mit IPX Version 2.12 getestet.                   *)
  16. (*                                                                          *)
  17. (*--------------------------------------------------------------------------*)
  18. (*                                                                          *)
  19. (*  MODIFIKATIONEN :                                                        *)
  20. (*                                                                          *)
  21. (*  Version  1.00A      20.02.91  R. Gilomen    Initial Version             *)
  22. (*  Version  1.10A      28.02.91  R. Gilomen    Neue Funktionen             *)
  23. (*                                              IPX_To_Addr                 *)
  24. (*                                              IPX_From_Addr               *)
  25. (*                                              IPX_Internetwork_Address    *)
  26. (*  Version  1.10B      07.03.91 R. Gilomen     Fehler in Funktion IPX_Done *)
  27. (*                                              behoben. Bei SEND wurde     *)
  28. (*                                              Source.Socket veraendert.   *)
  29. (*  Version  1.10C      13.06.91 R. Gilomen     Defaultwert fuer Parameter  *)
  30. (*                                              STAY_OPEN auf $FF gesetzt.  *)
  31. (*                                                                          *)
  32. (****************************************************************************)
  33.  
  34.  
  35. (*//////////////////////////////////////////////////////////////////////////*)
  36.                                    INTERFACE
  37. (*//////////////////////////////////////////////////////////////////////////*)
  38.  
  39.  
  40. (*==========================================================================*)
  41. (*                         DEKLARATIONEN / DEFINITIONEN                     *)
  42. (*==========================================================================*)
  43.  
  44. CONST
  45.  
  46. (* Allgemeine Deklarationen *)
  47.  
  48.          MAX_SOCKETS          = 20;    (* Maximale Anzahl konfigurierte     *)
  49.                                        (* Kommunikationssockel.             *)
  50.          MAX_DATA_SIZE        = 546;   (* Maximale Datenlaenge              *)
  51.          NET_LENGTH           = 4;     (* Laenge Netzwerkadresse            *)
  52.          NODE_LENGTH          = 6;     (* Laenge Knotenadresse              *)
  53.    
  54.  
  55. (* Code Deklarationen *)
  56.  
  57.          SEND                  = $10;
  58.          RECEIVE               = $20;
  59.  
  60.  
  61. (* Deklaration der Rueckgabewerte *)
  62.  
  63.          SUCCESS               = $00;
  64.          NOT_ENDED             = $10;
  65.          PARAMETER_ERROR       = $20;
  66.          NO_DESTINATION        = $21;
  67.          DEVICE_SW_ERROR       = $30;
  68.          SOCKET_TABLE_FULL     = $31;
  69.          PACKET_BAD            = $32;
  70.          PACKET_UNDELIVERIABLE = $33;
  71.          PACKET_OVERFLOW       = $34;
  72.          DEVICE_HW_ERROR       = $40;
  73.  
  74.  
  75. TYPE   S4Byte          =  ARRAY [1..4]  OF BYTE; (* Datentyp fuer Network   *)
  76.        S6Byte          =  ARRAY [1..6]  OF BYTE; (* Datentyp fuer Node      *)
  77.  
  78.                                                  (* Datentyp fuer Daten     *)
  79.        Data_Packet     = ARRAY [1..MAX_DATA_SIZE] OF CHAR;
  80.  
  81.        SData           = RECORD                  (* Daten und Laenge        *)
  82.                            Data   : Data_Packet;
  83.                            Length : WORD;
  84.                           END;
  85.  
  86.        Network_Address = RECORD                  (* Datentyp fuer NW-Adr.   *)
  87.                            Network     : S4Byte;
  88.                            Node        : S6Byte;
  89.                            Socket      : WORD;
  90.                          END;
  91.  
  92.  
  93. (*==========================================================================*)
  94. (*                         PROZEDUREN / FUNKTIONEN                          *)
  95. (*==========================================================================*)
  96.  
  97.  
  98. FUNCTION IPX_Setup : BYTE;
  99. (*--------------------------------------------------------------------------*)
  100. (*                                                                          *)
  101. (*  BESCHREIBUNG : Die Routine initialisiert die IPX-Software und deren     *)
  102. (*                 Funktion.                                                *)
  103. (*                                                                          *)
  104. (*                                                                          *)
  105. (*  PARAMETER    :  IN : -                                                  *)
  106. (*                                                                          *)
  107. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  108. (*                                                                          *)
  109. (*--------------------------------------------------------------------------*)
  110.  
  111.  
  112.  
  113. FUNCTION IPX_Open_Socket ( VAR Socket : WORD ) : BYTE;
  114. (*--------------------------------------------------------------------------*)
  115. (*                                                                          *)
  116. (*  BESCHREIBUNG :  Die Routine eroeffnet einen Kommunikationssockel.       *)
  117. (*                                                                          *)
  118. (*                                                                          *)
  119. (*  PARAMETER    :  IN : Socket        = Nummer des Sockels, der eroeffnet  *)
  120. (*                                       werden soll.                       *)
  121. (*                                                                          *)
  122. (*                  OUT: Socket        = Nummer des Sockels, der effektiv   *)
  123. (*                                       geoeffnet wurde.                   *)
  124. (*                                                                          *)
  125. (*                       Rueckgabewert = Fehlercode                         *)
  126. (*                                                                          *)
  127. (*--------------------------------------------------------------------------*)
  128.  
  129.  
  130.  
  131. FUNCTION IPX_Close_Socket ( Socket : WORD ) : BYTE;
  132. (*--------------------------------------------------------------------------*)
  133. (*                                                                          *)
  134. (*  BESCHREIBUNG :  Die Routine schliesst einen Kommunikationssockel.       *)
  135. (*                                                                          *)
  136. (*                                                                          *)
  137. (*  PARAMETER    :  IN : Socket        = Nummer des Sockels, der geschlos-  *)
  138. (*                                       sen werden soll.                   *)
  139. (*                                                                          *)
  140. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  141. (*                                                                          *)
  142. (*--------------------------------------------------------------------------*)
  143.  
  144.  
  145.  
  146. FUNCTION IPX_Send ( Socket    : WORD;
  147.                     Dest_Addr : Network_Address;
  148.                     Buffer    : SData
  149.                   ) : BYTE;
  150. (*--------------------------------------------------------------------------*)
  151. (*                                                                          *)
  152. (*  BESCHREIBUNG :  Die Routine dient zum senden von Daten an eine oder     *)
  153. (*                  mehrere Gegenstationen.                                 *)
  154. (*                                                                          *)
  155. (*                                                                          *)
  156. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der gesendet     *)
  157. (*                                       werden soll.                       *)
  158. (*                       Dest_Addr     = Vollstaendige Netwerkadresse der   *)
  159. (*                                       Gegenstation(en).                  *)
  160. (*                       Buffer        = Daten die gesendet werden und      *)
  161. (*                                       dessen Laenge.                     *)
  162. (*                                                                          *)
  163. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  164. (*                                                                          *)
  165. (*--------------------------------------------------------------------------*)
  166.  
  167.  
  168.  
  169. FUNCTION IPX_Receive ( Socket : WORD ) : BYTE;
  170. (*--------------------------------------------------------------------------*)
  171. (*                                                                          *)
  172. (*  BESCHREIBUNG :  Die Routine dient zum Empfangen von Daten einer Gegen-  *)
  173. (*                  station. Die Daten koennen, wenn das Kommando beendet   *)
  174. (*                  ist, mit der Funktion IPX_Done vom Netzwerk abgeholt    *)
  175. (*                  werden.                                                 *)
  176. (*                                                                          *)
  177. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der empfangen    *)
  178. (*                                       werden soll.                       *)
  179. (*                                                                          *)
  180. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  181. (*                                                                          *)
  182. (*--------------------------------------------------------------------------*)
  183.  
  184.  
  185.  
  186. FUNCTION IPX_Done ( Socket          : WORD;
  187.                     Code            : BYTE;
  188.                     VAR Source_Addr : Network_Address;
  189.                     VAR Buffer      : SData
  190.                   ) : BYTE;
  191. (*--------------------------------------------------------------------------*)
  192. (*                                                                          *)
  193. (*  BESCHREIBUNG :  Die Funktion liefert den Status einer vorher abgesetz-  *)
  194. (*                  ten Routine. Zurueckgegeben wird, ob die Routine schon  *)
  195. (*                  beendet ist oder nicht sowie eventuelle Daten.          *)
  196. (*                                                                          *)
  197. (*                                                                          *)
  198. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der die Funktion *)
  199. (*                                       ausgefuehrt werden soll.           *)
  200. (*                       Code          = Routine, deren Status ueberprueft  *)
  201. (*                                       werden soll.                       *)
  202. (*                                                                          *)
  203. (*                  OUT: Source_Addr   = Vollstaendige Netzwerkadresse der  *)
  204. (*                                       Gegenstation, von der Daten einge- *)
  205. (*                                       troffen sind.                      *)
  206. (*                       Buffer        = Buffer, in dem eventuelle Daten    *)
  207. (*                                       abgelegt werden koennen.           *)
  208. (*                       Rueckgabewert = Fehlercode                         *)
  209. (*                                                                          *)
  210. (*--------------------------------------------------------------------------*)
  211.  
  212.  
  213.  
  214. FUNCTION IPX_Internetwork_Address ( VAR Network : S4Byte;
  215.                                     VAR Node    : S6Byte
  216.                                   ) : BYTE;
  217. (*--------------------------------------------------------------------------*)
  218. (*                                                                          *)
  219. (*  BESCHREIBUNG :  Die Funktion liefert die Internetzwerkadresse der       *)
  220. (*                  jeweiligen Station.                                     *)
  221. (*                                                                          *)
  222. (*                                                                          *)
  223. (*  PARAMETER    :  OUT: Network       = Netzwerkadresse                    *)
  224. (*                       Node          = Knotenadresse                      *)
  225. (*                       Rueckgabewert = Fehlercode                         *)
  226. (*                                                                          *)
  227. (*--------------------------------------------------------------------------*)
  228.  
  229.  
  230.  
  231. FUNCTION IPX_To_Addr ( Network     : String;
  232.                        Node        : String;
  233.                        Socket      : String;
  234.                        VAR Addr    : Network_Address
  235.                      ) : BYTE;
  236. (*--------------------------------------------------------------------------*)
  237. (*                                                                          *)
  238. (*  BESCHREIBUNG : Die Routine konvertiert die Eingabestrings in die Daten- *)
  239. (*                 struktur Network_Address.                                *)
  240. (*                                                                          *)
  241. (*                                                                          *)
  242. (*  PARAMETER    :  IN : Network       = Netzwerkadresse die konvertiert    *)
  243. (*                                       werden soll.                       *)
  244. (*                       Node          = Knotenadresse die konvertiert      *)
  245. (*                                       werden soll.                       *)
  246. (*                       Socket        = Sockelnummer die konvertiert       *)
  247. (*                                       werden soll.                       *)
  248. (*                                                                          *)
  249. (*                  OUT: Addr          = Konvertierte vollsaendige Netz-    *)
  250. (*                                       werkadresse.                       *)
  251. (*                       Rueckgabewert = Fehlercode                         *)
  252. (*                                                                          *)
  253. (*--------------------------------------------------------------------------*)
  254.  
  255.  
  256.  
  257. FUNCTION IPX_From_Addr ( Addr            : Network_Address;
  258.                          VAR Network     : String;
  259.                          VAR Node        : String;
  260.                          VAR Socket      : String
  261.                        ) : BYTE;
  262. (*--------------------------------------------------------------------------*)
  263. (*                                                                          *)
  264. (*  BESCHREIBUNG : Die Routine konvertiert die vollstaendige Netzwerk-      *)
  265. (*                 adresse in String's.                                     *)
  266. (*                                                                          *)
  267. (*                                                                          *)
  268. (*  PARAMETER    :  IN : Addr          = Vollstaendige Netzwerkadresse      *)
  269. (*                                                                          *)
  270. (*                  OUT: Network       = Netzwerkadresse die konvertiert    *)
  271. (*                                       wurde.                             *)
  272. (*                       Node          = Knotenadresse die konvertiert      *)
  273. (*                                       wurde.                             *)
  274. (*                       Socket        = Sockelnummer die konvertiert       *)
  275. (*                                       wurde.                             *)
  276. (*                       Rueckgabewert = Fehlercode                         *)
  277. (*                                                                          *)
  278. (*--------------------------------------------------------------------------*)
  279.  
  280.  
  281.  
  282.  
  283. (*//////////////////////////////////////////////////////////////////////////*)
  284.                                  IMPLEMENTATION
  285. (*//////////////////////////////////////////////////////////////////////////*)
  286.  
  287.  
  288. (*==========================================================================*)
  289. (*                                UNITS IMPORT                              *)
  290. (*==========================================================================*)
  291.  
  292. USES     Dos;
  293.  
  294. (*==========================================================================*)
  295. (*                         DEKLARATIONEN / DEFINITIONEN                     *)
  296. (*==========================================================================*)
  297.  
  298.  
  299. CONST
  300.  
  301. (* Allgemeine Definitionen *)
  302.  
  303.          HEADER       = 30;            (* Groesse IPX-Header                *)
  304.          PACKET_SIZE  = 576;           (* IPX-Paket groesse                 *)
  305.  
  306.  
  307. (* Definitionen der IPX-Funktionen *)
  308.  
  309.          IPX_TST      = $7A00;         (* Vorbereiten fuer IPX Test         *)
  310.          MUX_INTR     = $2F;           (* Multiplex Interrupt               *)
  311.          OPEN_SOCKET  = $0000;         (* Oeffnet einen Sockel              *)
  312.          CLOSE_SOCKET = $0001;         (* Schliesst einen Sockel            *)
  313.          GET_TARGET   = $0002;         (* Pruefe Gegenstation               *)
  314.          DO_SEND      = $0003;         (* Sendet ein Paket                  *)
  315.          DO_RECEIVE   = $0004;         (* Empfaengt Pakete                  *)
  316.          GET_ADDR     = $0009;         (* Bestimmt Internetzwerkadresse     *)
  317.  
  318.  
  319. (* Definitionen der IPX-Parameter *)
  320.  
  321.          STAY_OPEN    = $FF;           (* $00 : Sockel bleibt geoeffnet,    *)
  322.                                        (* bis er explizit geschlossen wird  *)
  323.                                        (* oder das Programm terminiert.     *)
  324.                                        (* $FF : Sockel bleibt geoeffnet,    *)
  325.                                        (* bis er explizit geschlossen wird. *)
  326.                                        (* Wird benoetigt fuer TSR-Programme.*)
  327.  
  328. (* Definitionen der IPX-Rueckgabewerte *)
  329.  
  330.          IPX_LOADED   = $FF;           (* IPX ist geladen                   *)
  331.          OPENED       = $00;           (* Sockel erfolgreich geoeffnet      *)
  332.          ALREADY_OPEN = $FF;           (* Sockel ist bereits goeffnet       *)
  333.          TABLE_FULL   = $FE;           (* Sockel Tabelle ist voll           *)
  334.          EXIST        = $00;           (* Weg zu Gegenstation existiert     *)
  335.          NO_SOCKET    = $FF;           (* Sockel existiert nicht            *)
  336.          SEND_OK      = $00;           (* Senden war erfolgreich            *)
  337.          SOCKET_ERROR = $FC;           (* Sockel existiert nicht mehr       *)
  338.          SIZE_ERROR   = $FD;           (* Paketgroesse nicht korrekt        *)
  339.          UNDELIV      = $FE;           (* Paket nicht ausgeliefert          *)
  340.          OVERFLOW     = $FD;           (* Buffer zu klein                   *)
  341.          HW_ERROR     = $FF;           (* Hardware defekt                   *)
  342.          REC_OK       = $00;           (* Paket erfolgreich empfangen       *)
  343.  
  344.  
  345. (* Definition der ECB-Parameter *)
  346.  
  347.          FINISHED     = $00;           (* Routine beendet                   *)
  348.          FRAG_COUNT   = 1;             (* Anzahl Fragmente                  *)
  349.          UNKNOWN      = 0;             (* Unbekannter Paket Typ             *)
  350.  
  351. (* Deklarationen *)
  352.  
  353. TYPE     S12Byte      = ARRAY [1..12] OF BYTE;   (* Interner Datentyp       *)
  354.  
  355.          IPX_Packet   = RECORD         (* IPX-Paket Struktur                *)
  356.                           CheckSum         : WORD;
  357.                           Length           : WORD;
  358.                           TransportControl : BYTE;
  359.                           PacketType       : BYTE;
  360.                           Destination      : Network_Address;
  361.                           Source           : Network_Address;
  362.                           IPX_Data         : Data_Packet;
  363.                         END;
  364.  
  365.          ECB_Fragment = RECORD         (* Fragment der ECB Struktur         *)
  366.                           Address : ^IPX_Packet;
  367.                           Size    : WORD;
  368.                         END;
  369.  
  370.          ECB = RECORD                  (* ECB Datenstruktur                 *)
  371.                 Link_Adress        : S4Byte;
  372.                 ESR_Address        : ^BYTE;
  373.                 InUseFlag          : BYTE;
  374.                 CompletionCode     : BYTE;
  375.                 SocketNumber       : WORD;
  376.                 IPX_Workspace      : S4Byte;
  377.                 DriverWorkspace    : S12Byte;
  378.                 ImmediateAddress   : S6Byte;
  379.                 FragmentCount      : WORD;
  380.                 FragDescr          : ECB_Fragment;
  381.                END;
  382.  
  383.  
  384.          Int_Addr = RECORD             (* Datenstruktur Internetzwerkadr.   *)
  385.                       Network : S4Byte;
  386.                       Node    : S6Byte;
  387.                     END;
  388.  
  389.  
  390. VAR      IPX_Location : ARRAY [1..2] OF WORD;    (* Adresse von IPX         *)
  391.  
  392.                                                  (* Array in dem die ECB's  *)
  393.                                                  (* verwaltet werden.       *)
  394.          ECB_Table    : ARRAY [1..MAX_SOCKETS] OF ^ECB;
  395.  
  396.  
  397. (*==========================================================================*)
  398. (*                         PROZEDUREN / FUNKTIONEN                          *)
  399. (*==========================================================================*)
  400.  
  401.  
  402. PROCEDURE IPX_Call ( VAR Regs : Registers );
  403. (*--------------------------------------------------------------------------*)
  404. (*                                                                          *)
  405. (*  BESCHREIBUNG :  Diese Prozedur setzt die in Regs spezifizierten         *)
  406. (*                  Register des Prozessors. Anschliessend wird ein IPX-    *)
  407. (*                  Call ausgefuehrt und die Register wieder ausgelesen.    *)
  408. (*                  Es werden nicht alle Register der Datenstruktur         *)
  409. (*                  Regs uebernommen!                                       *)
  410. (*                                                                          *)
  411. (*  PARAMETER    :  IN : Regs          = Register, die gesetzt werden       *)
  412. (*                                       sollen.                            *)
  413. (*                                                                          *)
  414. (*                  OUT: Regs          = Register, die vom IPX gesetzt      *)
  415. (*                                       wurden (Return values).            *)
  416. (*                                                                          *)
  417. (*--------------------------------------------------------------------------*)
  418.  
  419. VAR      Temp_AX, Temp_BX, Temp_CX, Temp_DX,
  420.          Temp_ES, Temp_SI, Temp_DI               : WORD;
  421.  
  422. BEGIN
  423.  Temp_AX := Regs.AX;
  424.  Temp_BX := Regs.BX;
  425.  Temp_CX := Regs.CX;
  426.  Temp_DX := Regs.DX;
  427.  Temp_SI := Regs.SI;
  428.  Temp_ES := Regs.ES;
  429.  Temp_DI := Regs.DI;
  430.  ASM
  431.   PUSH BP                              (* Register sichern                  *)
  432.   PUSH SP
  433.   PUSH SS
  434.   PUSH DS
  435.   PUSH AX
  436.   PUSH BX
  437.   PUSH CX
  438.   PUSH DX
  439.   PUSH SI
  440.   PUSH ES
  441.   PUSH DI
  442.   MOV AX, Temp_AX                      (* Register setzen                   *)
  443.   MOV BX, Temp_BX
  444.   MOV CX, Temp_CX
  445.   MOV DX, Temp_DX
  446.   MOV SI, Temp_SI
  447.   MOV ES, Temp_ES
  448.   MOV DI, Temp_DI
  449.   CALL DWORD PTR IPX_Location          (* IPX aufrufen                      *)
  450.   MOV Temp_AX, AX                      (* Register auslesen                 *)
  451.   MOV Temp_BX, BX
  452.   MOV Temp_CX, CX
  453.   MOV Temp_DX, DX
  454.   MOV Temp_SI, SI
  455.   MOV Temp_ES, ES
  456.   MOV Temp_DI, DI
  457.   POP DI
  458.   POP ES                               (* Gesicherte Register wieder        *)
  459.   POP SI                               (* zuruecksetzen.                    *)
  460.   POP DX
  461.   POP CX
  462.   POP BX
  463.   POP AX
  464.   POP DS                               
  465.   POP SS                               
  466.   POP SP
  467.   POP BP
  468.  END;
  469.  
  470.  Regs.AX := Temp_AX;
  471.  Regs.BX := Temp_BX;
  472.  Regs.CX := Temp_CX;
  473.  Regs.DX := Temp_DX;
  474.  Regs.SI := Temp_SI;
  475.  Regs.ES := Temp_ES;
  476.  Regs.DI := Temp_DI;
  477. END;
  478.  
  479.  
  480.  
  481. FUNCTION IPX_Setup : BYTE;
  482. (*--------------------------------------------------------------------------*)
  483. (*                                                                          *)
  484. (*  BESCHREIBUNG : Die Routine initialisiert die IPX-Software und deren     *)
  485. (*                 Funktion.                                                *)
  486. (*                                                                          *)
  487. (*                                                                          *)
  488. (*  PARAMETER    :  IN : -                                                  *)
  489. (*                                                                          *)
  490. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  491. (*                                                                          *)
  492. (*--------------------------------------------------------------------------*)
  493.  
  494. VAR      i        : INTEGER;           (* Laufvariable                      *)
  495.          Temp_Reg : Registers;         (* Temporaere Register fuer Int.     *)
  496.  
  497.  
  498. BEGIN
  499.   Temp_Reg.AX := IPX_TST;              (* Test ob IPX geladen.              *)
  500.   Intr (MUX_INTR,Temp_Reg);
  501.   IF (Temp_Reg.AL <> IPX_LOADED) THEN
  502.   BEGIN
  503.     IPX_Setup := DEVICE_SW_ERROR;      (* IPX nicht geladen                 *)
  504.     EXIT;
  505.   END;
  506.   Temp_Reg.AX := Temp_Reg.ES;
  507.   IPX_Location[1] := Temp_Reg.DI;      (* Adresse von IPX sichern           *)
  508.   IPX_Location[2] := Temp_Reg.AX;
  509.  
  510.   FOR i := 1 TO MAX_SOCKETS DO         (* Array fuer ECB init.              *)
  511.     ECB_Table[i] := NIL;
  512.  
  513.   IPX_Setup := SUCCESS;                (* Initialisierung erfolgreich       *)
  514. END;
  515.  
  516.  
  517.  
  518. FUNCTION IPX_Open_Socket ( VAR Socket : WORD ) : BYTE;
  519. (*--------------------------------------------------------------------------*)
  520. (*                                                                          *)
  521. (*  BESCHREIBUNG :  Die Routine eroeffnet einen Kommunikationssockel.       *)
  522. (*                                                                          *)
  523. (*                                                                          *)
  524. (*  PARAMETER    :  IN : Socket        = Nummer des Sockels, der eroeffnet  *)
  525. (*                                       werden soll.                       *)
  526. (*                                                                          *)
  527. (*                  OUT: Socket        = Nummer des Sockels, der effektiv   *)
  528. (*                                       geoeffnet wurde.                   *)
  529. (*                                                                          *)
  530. (*                       Rueckgabewert = Fehlercode                         *)
  531. (*                                                                          *)
  532. (*--------------------------------------------------------------------------*)
  533.  
  534. VAR      i        : INTEGER;           (* Laufvariable                      *)
  535.          Index    : INTEGER;           (* Index auf ECB_Table               *)
  536.  
  537.          Temp_Reg : Registers;         (* Temporaere Register fuer IPX-Call *)
  538.  
  539.  
  540. BEGIN
  541.   Socket := Swap(Socket);              (* In Motorola Format konvertieren   *)
  542.  
  543.   FOR i := 1 TO MAX_SOCKETS DO         (* Pruefen, ob Sockel existiert      *)
  544.     IF ECB_Table[i] <> NIL THEN
  545.       IF Socket = ECB_Table[i]^.SocketNumber THEN
  546.       BEGIN
  547.         IPX_Open_Socket := PARAMETER_ERROR;
  548.         EXIT;
  549.       END;
  550.  
  551.   Index := 1;
  552.   WHILE (ECB_Table[Index] <> NIL) DO   (* Pruefen, ob alle Sockel belegt    *)
  553.   BEGIN                                (* falls es noch freie ECB hat,      *)
  554.     IF Index >= MAX_SOCKETS THEN       (* steht Index auf einem solchen.    *)
  555.     BEGIN
  556.       IPX_Open_Socket := SOCKET_TABLE_FULL;
  557.       EXIT;
  558.     END;
  559.     Index := Index + 1;
  560.   END;
  561.  
  562.   Temp_Reg.BX := OPEN_SOCKET;          (* Register fuer Call vorbereiten    *)
  563.   Temp_Reg.AL := STAY_OPEN;
  564.   Temp_Reg.DX := Socket;
  565.  
  566.   IPX_Call (Temp_Reg);
  567.  
  568.   Socket := Temp_Reg.DX;               (* Register auslesen                 *)
  569.  
  570.   IF Temp_Reg.AL <> OPENED THEN        (* IPX nicht i.O.                    *)
  571.   BEGIN
  572.     IPX_Open_Socket := DEVICE_SW_ERROR;
  573.     EXIT;
  574.   END;
  575.  
  576.   NEW (ECB_Table[Index]);              (* Vollstaendiger ECB erzeugen       *)
  577.   NEW (ECB_Table[Index]^.FragDescr.Address);
  578.   ECB_Table[Index]^.SocketNumber := Socket;
  579.  
  580.   Socket := Swap(Socket);              (* Zurueck in INTEL Format konv.     *)
  581.   IPX_Open_Socket := SUCCESS;
  582.  
  583. END;
  584.  
  585.  
  586.  
  587. FUNCTION IPX_Close_Socket ( Socket : WORD ) : BYTE;
  588. (*--------------------------------------------------------------------------*)
  589. (*                                                                          *)
  590. (*  BESCHREIBUNG :  Die Routine schliesset einen Kommunikationssockel.      *)
  591. (*                                                                          *)
  592. (*                                                                          *)
  593. (*  PARAMETER    :  IN : Socket        = Nummer des Sockels, der geschlos-  *)
  594. (*                                       sen werden soll.                   *)
  595. (*                                                                          *)
  596. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  597. (*                                                                          *)
  598. (*--------------------------------------------------------------------------*)
  599.  
  600. VAR      Index    : INTEGER;           (* Index auf ECB_Table               *)
  601.  
  602.          Temp_Reg : Registers;         (* Temporaere Register fuer IPX-Call *)
  603.  
  604.  
  605. BEGIN
  606.   Socket := Swap(Socket);              (* In Motorola Format konvertieren   *)
  607.  
  608.   Index := 1;                          (* Sockel suchen                     *)
  609.   WHILE (ECB_Table[Index]^.SocketNumber <> Socket) DO
  610.   BEGIN                               
  611.     IF Index >= MAX_SOCKETS THEN
  612.     BEGIN
  613.       IPX_Close_Socket := PARAMETER_ERROR;       (* Sockel existiert nicht  *)
  614.       EXIT;
  615.     END;
  616.     Index := Index + 1;
  617.   END;
  618.  
  619.   Temp_Reg.BX := CLOSE_SOCKET;         (* Register fuer Call vorbereiten    *)
  620.   Temp_Reg.DX := Socket;
  621.  
  622.   IPX_Call (Temp_Reg);
  623.  
  624.                                        (* Allozierter Speicher freigeben    *)
  625.   DISPOSE (ECB_Table[Index]^.FragDescr.Address);
  626.   ECB_Table[Index]^.FragDescr.Address := NIL;
  627.   DISPOSE (ECB_Table[Index]);
  628.   ECB_Table[Index] := NIL;
  629.  
  630.  
  631.   IPX_Close_Socket := SUCCESS;
  632.  
  633. END;
  634.  
  635.  
  636.  
  637. FUNCTION IPX_Send ( Socket    : WORD;
  638.                     Dest_Addr : Network_Address;
  639.                     Buffer    : SData
  640.                   ) : BYTE;
  641. (*--------------------------------------------------------------------------*)
  642. (*                                                                          *)
  643. (*  BESCHREIBUNG :  Die Routine dient zum senden von Daten an eine oder     *)
  644. (*                  mehrere Gegenstation(en).                               *)
  645. (*                                                                          *)
  646. (*                                                                          *)
  647. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der gesendet     *)
  648. (*                                       werden soll.                       *)
  649. (*                       Dest_Addr     = Vollstaendige Netwerkadresse der   *)
  650. (*                                       Gegenstation(en).                  *)
  651. (*                       Buffer        = Daten die gesendet werden und      *)
  652. (*                                       dessen Laenge.                     *)
  653. (*                                                                          *)
  654. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  655. (*                                                                          *)
  656. (*--------------------------------------------------------------------------*)
  657.  
  658. VAR      i         : INTEGER;          (* Laufvariable                      *)
  659.          Index     : INTEGER;          (* Index auf ECB_Table               *)
  660.  
  661.          Temp_Reg  : Registers;        (* Temporaere Register fuer IPX-Call *)
  662.  
  663.          Temp_Imm_Addr : S6Byte;       (* Temporaere ImmdediateAddress      *)
  664.  
  665.          Temp_Addr : S12Byte;          (* Temporaere Internetworkadresse    *)
  666.  
  667.  
  668. BEGIN
  669.   Socket := Swap(Socket);              (* In Motorola Format konvertieren   *)
  670.   Dest_Addr.Socket := Swap(Dest_Addr.Socket);
  671.  
  672.   Index := 1;                          (* Sockel suchen                     *)
  673.   WHILE (ECB_Table[Index]^.SocketNumber <> Socket) DO
  674.   BEGIN
  675.     IF Index >= MAX_SOCKETS THEN
  676.     BEGIN
  677.       IPX_Send := PARAMETER_ERROR;     (* Sockel existiert nicht            *)
  678.       EXIT;
  679.     END;
  680.     Index := Index + 1;
  681.   END;
  682.  
  683.   IF Buffer.Length > MAX_DATA_SIZE THEN     (* Laenge der Daten pruefen     *)
  684.   BEGIN
  685.     IPX_Send := PARAMETER_ERROR;
  686.     EXIT;
  687.   END;
  688.  
  689.   WITH Dest_Addr DO                    (* Pruefe ob Gegenstation erreichbar *)
  690.   BEGIN
  691.     FOR i := 1 TO NET_LENGTH DO        (* Internetzwerkadresse zusammenst.  *)
  692.       Temp_Addr[i] := Network[i];
  693.     FOR i := 1 TO NODE_LENGTH DO
  694.       Temp_Addr[i + NET_LENGTH] := Node[i];
  695.     Temp_Addr[11] := Lo(Socket);       (* Low-Byte                          *)
  696.     Temp_Addr[12] := HI(Socket);       (* High-Byte                         *)
  697.   END;
  698.  
  699.   Temp_Reg.ES := Seg(Temp_Addr);       (* Register fuer Call vorbereiten    *)
  700.   Temp_Reg.SI := Ofs(Temp_Addr);
  701.  
  702.   Temp_Reg.DI := Ofs(Temp_Imm_Addr);
  703.   Temp_Reg.BX := GET_TARGET;
  704.  
  705.   IPX_Call (Temp_Reg);
  706.  
  707.   ECB_Table[Index]^.ImmediateAddress := Temp_Imm_Addr;
  708.  
  709.   IF Temp_Reg.AL <> EXIST THEN
  710.   BEGIN
  711.     IPX_Send := NO_DESTINATION;        (* Weg nicht verfuegbar              *)
  712.     EXIT;
  713.   END;
  714.  
  715.   WITH ECB_Table[Index]^ DO            (* ECB mit Parametern fuellen        *)
  716.   BEGIN
  717.     ESR_Address := NIL;
  718.     SocketNumber := Socket;
  719.     InUseFlag := FINISHED;
  720.     FragmentCount := FRAG_COUNT;
  721.     WITH FragDescr.Address^ DO         (* IPX-Header vorbereiten            *)
  722.     BEGIN
  723.       PacketType := UNKNOWN;
  724.       WITH Destination DO
  725.       BEGIN
  726.         Network := Dest_Addr.Network;
  727.         Node := Dest_Addr.Node;
  728.         Socket := Dest_Addr.Socket;
  729.       END;
  730.       IPX_Data := Buffer.Data;
  731.     END;
  732.     FragDescr.Size := Buffer.Length + 30;
  733.   END;
  734.  
  735.   Temp_Reg.ES := Seg(ECB_Table[Index]^);  (* Register fuer Call vorbereiten *)
  736.   Temp_Reg.SI := Ofs(ECB_Table[Index]^);
  737.   Temp_Reg.BX := DO_SEND;
  738.  
  739.   IPX_Call (Temp_Reg);
  740.  
  741.   IPX_Send := SUCCESS;
  742.  
  743. END;
  744.  
  745.  
  746.  
  747. FUNCTION IPX_Receive ( Socket : WORD ) : BYTE;
  748. (*--------------------------------------------------------------------------*)
  749. (*                                                                          *)
  750. (*  BESCHREIBUNG :  Die Routine dient zum Empfangen von Daten einer Gegen-  *)
  751. (*                  station. Die Daten koennen, wenn das Kommando beendet   *)
  752. (*                  ist, mit der Funktion IPX_Done vom Netzwerk abgeholt    *)
  753. (*                  werden.                                                 *)
  754. (*                                                                          *)
  755. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der empfangen    *)
  756. (*                                       werden soll.                       *)
  757. (*                                                                          *)
  758. (*                  OUT: Rueckgabewert = Fehlercode                         *)
  759. (*                                                                          *)
  760. (*--------------------------------------------------------------------------*)
  761.  
  762. VAR      Index     : INTEGER;          (* Index auf ECB                     *)
  763.          i         : INTEGER;          (* Laufvariable                      *)
  764.  
  765.          Temp_Reg  : Registers;        (* Temporaere Register fuer IPX-Call *)
  766.  
  767.  
  768. BEGIN
  769.   Socket := Swap(Socket);              (* In Motorola Format konvertieren   *)
  770.  
  771.   Index := 1;                          (* Sockel suchen                     *)
  772.   WHILE (ECB_Table[Index]^.SocketNumber <> Socket) DO
  773.   BEGIN
  774.     IF Index >= MAX_SOCKETS THEN
  775.     BEGIN
  776.       IPX_Receive := PARAMETER_ERROR;  (* Sockel existiert nicht            *)
  777.       EXIT;
  778.     END;
  779.     Index := Index + 1;
  780.   END;
  781.  
  782.   WITH ECB_Table[Index]^ DO            (* ECB mit Parametern fuellen        *)
  783.   BEGIN
  784.     ESR_Address := NIL;
  785.     FragmentCount := FRAG_COUNT;
  786.     FragDescr.Size := PACKET_SIZE;
  787.     InUseFlag := FINISHED;
  788.   END;
  789.  
  790.   Temp_Reg.ES := Seg(ECB_Table[Index]^);    (* Register vorbereiten         *)
  791.   Temp_Reg.SI := Ofs(ECB_Table[Index]^);
  792.   Temp_Reg.BX := DO_RECEIVE;
  793.  
  794.   IPX_Call (Temp_Reg);
  795.  
  796.   IF Temp_Reg.AL = NO_SOCKET THEN
  797.   BEGIN
  798.     IPX_Receive := DEVICE_SW_ERROR;
  799.     EXIT;
  800.   END;
  801.  
  802.   IPX_Receive := SUCCESS;
  803.  
  804. END;
  805.  
  806.  
  807.  
  808.  
  809. FUNCTION IPX_Done ( Socket          : WORD;
  810.                     Code            : BYTE;
  811.                     VAR Source_Addr : Network_Address;
  812.                     VAR Buffer      : SData
  813.                   ) : BYTE;
  814. (*--------------------------------------------------------------------------*)
  815. (*                                                                          *)
  816. (*  BESCHREIBUNG :  Die Funktion liefert den Status einer vorher abgesetz-  *)
  817. (*                  ten Routine. Zurueckgegeben wird, ob die Routine schon  *)
  818. (*                  beendet ist oder nicht sowie eventuelle Daten.          *)
  819. (*                                                                          *)
  820. (*                                                                          *)
  821. (*  PARAMETER    :  IN : Socket        = Sockelnummer, auf der die Funktion *)
  822. (*                                       ausgefuehrt werden soll.           *)
  823. (*                       Code          = Routine, deren Status ueberprueft  *)
  824. (*                                       werden soll.                       *)
  825. (*                                                                          *)
  826. (*                  OUT: Source_Addr   = Vollstaendige Netzwerkadresse der  *)
  827. (*                                       Gegenstation, von der Daten einge- *)
  828. (*                                       troffen sind.                      *)
  829. (*                       Buffer        = Buffer, in dem eventuelle Daten    *)
  830. (*                                       abgelegt werden koennen.           *)
  831. (*                       Rueckgabewert = Fehlercode                         *)
  832. (*                                                                          *)
  833. (*--------------------------------------------------------------------------*)
  834.  
  835. VAR      i         : INTEGER;          (* Laufvariable                      *)
  836.          Index     : INTEGER;          (* Index auf ECB_Table               *)
  837.  
  838.          Temp_Reg  : Registers;        (* Temporaere Register fuer IPX-Call *)
  839.  
  840.  
  841. BEGIN
  842.   Socket := Swap(Socket);              (* In Motorola Format konvertieren   *)
  843.  
  844.   Index := 1;                          (* Sockel suchen                     *)
  845.   WHILE (ECB_Table[Index]^.SocketNumber <> Socket) DO
  846.   BEGIN
  847.     IF Index >= MAX_SOCKETS THEN
  848.     BEGIN
  849.       IPX_Done := PARAMETER_ERROR;     (* Sockel existiert nicht            *)
  850.       EXIT;
  851.     END;
  852.     Index := Index + 1;
  853.   END;
  854.                                        (* Test ob Funktion beendet          *)
  855.   IF ECB_Table[Index]^.InUseFlag <> FINISHED THEN
  856.   BEGIN
  857.      IPX_Done := NOT_ENDED;
  858.      EXIT;
  859.   END;
  860.  
  861.   CASE Code OF
  862.     SEND :
  863.     BEGIN                              (* Send Completion Code auswerten    *)
  864.       CASE ECB_Table[Index]^.CompletionCode OF
  865.         SEND_OK      : ;
  866.         SOCKET_ERROR : BEGIN
  867.                          IPX_Done := DEVICE_SW_ERROR;
  868.                          EXIT;
  869.                        END;
  870.         SIZE_ERROR   : BEGIN
  871.                          IPX_Done := PACKET_BAD;
  872.                          EXIT;
  873.                        END;
  874.         UNDELIV      : BEGIN
  875.                          IPX_Done := PACKET_UNDELIVERIABLE;
  876.                          EXIT;
  877.                        END;
  878.         HW_ERROR     : BEGIN
  879.                          IPX_Done := DEVICE_HW_ERROR;
  880.                          EXIT;
  881.                        END
  882.         ELSE           BEGIN
  883.                          IPX_Done := DEVICE_SW_ERROR;
  884.                          EXIT;
  885.                        END;
  886.       END;
  887.     END;
  888.     RECEIVE :
  889.     BEGIN                             (* Receive Completion Code auswerten  *)
  890.       CASE ECB_Table[Index]^.CompletionCode OF
  891.         REC_OK : BEGIN                 (* Daten in Benutzerbuffer kopieren  *)
  892.                    WITH ECB_Table[Index]^.FragDescr DO
  893.                    BEGIN
  894.                      Buffer.Data := Address^.IPX_Data;
  895.                      Buffer.Length := Swap(Address^.Length) - HEADER;
  896.                    END;
  897.                                        (* Netzwerkadresse umkopieren        *)
  898.                    WITH ECB_Table[Index]^.FragDescr.Address^.Source DO
  899.                    BEGIN
  900.                      Source_Addr.Network := Network;
  901.                      Source_Addr.Node := Node;
  902.                      Source_Addr.Socket := Swap(Socket);
  903.                    END;
  904.                  END;
  905.         SOCKET_ERROR : BEGIN
  906.                          IPX_Done := DEVICE_SW_ERROR;
  907.                          EXIT;
  908.                        END;
  909.         OVERFLOW     : BEGIN
  910.                          IPX_Done := PACKET_OVERFLOW;
  911.                          EXIT;
  912.                        END;
  913.         NO_SOCKET    : BEGIN
  914.                          IPX_Done := DEVICE_SW_ERROR;
  915.                          EXIT;
  916.                        END
  917.         ELSE           BEGIN
  918.                          IPX_Done := DEVICE_SW_ERROR;
  919.                          EXIT;
  920.                        END;
  921.       END;
  922.     END
  923.     ELSE  BEGIN
  924.             IPX_Done := PARAMETER_ERROR;
  925.           EXIT;
  926.     END;
  927.  
  928.   END;
  929.  
  930.   IPX_Done := SUCCESS;
  931.  
  932. END;
  933.  
  934.  
  935.  
  936. FUNCTION IPX_Internetwork_Address ( VAR Network : S4Byte;
  937.                                     VAR Node    : S6Byte
  938.                                   ) : BYTE;
  939. (*--------------------------------------------------------------------------*)
  940. (*                                                                          *)
  941. (*  BESCHREIBUNG :  Die Funktion liefert die Internetzwerkadresse der       *)
  942. (*                  jeweiligen Station.                                     *)
  943. (*                                                                          *)
  944. (*                                                                          *)
  945. (*  PARAMETER    :  OUT: Network       = Netzwerkadresse                    *)
  946. (*                       Node          = Knotenadresse                      *)
  947. (*                       Rueckgabewert = Fehlercode                         *)
  948. (*                                                                          *)
  949. (*--------------------------------------------------------------------------*)
  950.  
  951. VAR      Temp_Reg     : Registers;     (* Temporaere Register fuer IPX-Call *)
  952.  
  953.          Reply_Buffer : Int_Addr;      (* Temporaerer Buffer fuer Adressen  *)
  954.  
  955. BEGIN
  956.  
  957.   Temp_Reg.ES := Seg(Reply_Buffer);    (* Register vorbereiten              *)
  958.   Temp_Reg.SI := Ofs(Reply_Buffer);
  959.   Temp_Reg.BX := GET_ADDR;
  960.  
  961.   IPX_Call (Temp_Reg);
  962.  
  963.   Network := Reply_Buffer.Network;     (* Daten umkopieren                  *)
  964.   Node := Reply_Buffer.Node;
  965.  
  966.   IPX_Internetwork_Address := SUCCESS;
  967.  
  968. END;
  969.  
  970.  
  971.  
  972. FUNCTION IPX_To_Addr ( Network     : String;
  973.                        Node        : String;
  974.                        Socket      : String;
  975.                        VAR Addr    : Network_Address
  976.                      ) : BYTE;
  977. (*--------------------------------------------------------------------------*)
  978. (*                                                                          *)
  979. (*  BESCHREIBUNG : Die Routine konvertiert die Eingabestrings in die Daten- *)
  980. (*                 struktur Network_Address.                                *)
  981. (*                                                                          *)
  982. (*                                                                          *)
  983. (*  PARAMETER    :  IN : Network       = Netzwerkadresse die konvertiert    *)
  984. (*                                       werden soll.                       *)
  985. (*                       Node          = Knotenadresse die konvertiert      *)
  986. (*                                       werden soll.                       *)
  987. (*                       Socket        = Sockelnummer die konvertiert       *)
  988. (*                                       werden soll.                       *)
  989. (*                                                                          *)
  990. (*                  OUT: Addr          = Konvertierte vollsaendige Netz-    *)
  991. (*                                       werkadresse.                       *)
  992. (*                       Rueckgabewert = Fehlercode                         *)
  993. (*                                                                          *)
  994. (*--------------------------------------------------------------------------*)
  995.  
  996. VAR      i,n,Code  : INTEGER;
  997.          c         : CHAR;
  998.          Temp      : BYTE;
  999.  
  1000. BEGIN
  1001.  
  1002.   (* Pruefe Netzwerk und Node Laenge *)
  1003.   IF (ORD(Network[0]) <> (2 * NET_LENGTH)) OR
  1004.      (ORD(Node[0]) <> (2 * NODE_LENGTH)) THEN
  1005.   BEGIN
  1006.     IPX_To_Addr := PARAMETER_ERROR;
  1007.     EXIT;
  1008.   END;
  1009.  
  1010.   (* Netzwerkadresse konvertieren *)
  1011.   i := 1;
  1012.   n := 1;
  1013.   WHILE ( i <= (2 * NET_LENGTH)) DO
  1014.   BEGIN
  1015.     c := UPCASE(Network[i]);
  1016.     CASE c OF
  1017.       'A'..'F': Addr.Network[n] := ORD(c) - 55;
  1018.       '0'..'9': Addr.Network[n] := ORD(c) - 48
  1019.     ELSE        BEGIN
  1020.                   IPX_To_Addr := PARAMETER_ERROR;
  1021.                   EXIT;
  1022.                 END;
  1023.     END;
  1024.     Addr.Network[n] := Addr.Network[n] SHL 4;
  1025.     c := UPCASE(Network[i + 1]);
  1026.     CASE c OF
  1027.       'A'..'F': Temp := ORD(c) - 55;
  1028.       '0'..'9': Temp := ORD(c) - 48;
  1029.     ELSE        BEGIN
  1030.                   IPX_To_Addr := PARAMETER_ERROR;
  1031.                   EXIT;
  1032.                 END;
  1033.     END;
  1034.     Addr.Network[n] := Addr.Network[n] + Temp;
  1035.     i := i + 2;
  1036.     n := n + 1;
  1037.   END;
  1038.  
  1039.  
  1040.   (* Node-Adresse konvertieren *)
  1041.   i := 1;
  1042.   n := 1;
  1043.   WHILE ( i <= (2 * NODE_LENGTH)) DO
  1044.   BEGIN
  1045.     c := UPCASE(Node[i]);
  1046.     CASE c OF
  1047.       'A'..'F': Addr.Node[n] := ORD(c) - 55;
  1048.       '0'..'9': Addr.Node[n] := ORD(c) - 48;
  1049.     ELSE        BEGIN
  1050.                   IPX_To_Addr := PARAMETER_ERROR;
  1051.                   EXIT;
  1052.                 END;
  1053.     END;
  1054.     Addr.Node[n] := Addr.Node[n] SHL 4;
  1055.     c := UPCASE(Node[i + 1]);
  1056.     CASE c OF
  1057.       'A'..'F': Temp := ORD(c) - 55;
  1058.       '0'..'9': Temp := ORD(c) - 48;
  1059.     ELSE        BEGIN
  1060.                   IPX_To_Addr := PARAMETER_ERROR;
  1061.                   EXIT;
  1062.                 END;
  1063.     END;
  1064.     Addr.Node[n] := Addr.Node[n] + Temp;
  1065.     i := i + 2;
  1066.     n := n + 1;
  1067.   END;
  1068.  
  1069.   (* Sockelnummer konvertieren *)
  1070.   VAL (Socket,Addr.Socket,Code);
  1071.   IF Code <> 0 THEN
  1072.   BEGIN
  1073.     IPX_To_Addr := PARAMETER_ERROR;
  1074.     EXIT;
  1075.   END;
  1076.  
  1077.   IPX_To_Addr := SUCCESS;
  1078.  
  1079. END;
  1080.  
  1081.  
  1082.  
  1083. FUNCTION IPX_From_Addr ( Addr            : Network_Address;
  1084.                          VAR Network     : String;
  1085.                          VAR Node        : String;
  1086.                          VAR Socket      : String
  1087.                        ) : BYTE;
  1088. (*--------------------------------------------------------------------------*)
  1089. (*                                                                          *)
  1090. (*  BESCHREIBUNG : Die Routine konvertiert die vollstaendige Netzwerk-      *)
  1091. (*                 adresse in String's.                                     *)
  1092. (*                                                                          *)
  1093. (*                                                                          *)
  1094. (*  PARAMETER    :  IN : Addr          = Vollstaendige Netzwerkadresse      *)
  1095. (*                                                                          *)
  1096. (*                  OUT: Network       = Netzwerkadresse die konvertiert    *)
  1097. (*                                       wurde.                             *)
  1098. (*                       Node          = Knotenadresse die konvertiert      *)
  1099. (*                                       wurde.                             *)
  1100. (*                       Socket        = Sockelnummer die konvertiert       *)
  1101. (*                                       wurde.                             *)
  1102. (*                       Rueckgabewert = Fehlercode                         *)
  1103. (*                                                                          *)
  1104. (*--------------------------------------------------------------------------*)
  1105.  
  1106. VAR      i,n,Code      : INTEGER;
  1107.          c             : CHAR;
  1108.          TempHi,TempLo : BYTE;
  1109.  
  1110. BEGIN
  1111.  
  1112.   (* Netzwerkadresse konvertieren *)
  1113.   i := 1;
  1114.   n := 1;
  1115.   WHILE ( i <= (2 * NET_LENGTH)) DO
  1116.   BEGIN
  1117.     TempHi := Addr.Network[n] DIV 16;  (* Hi-Nibble                         *)
  1118.     CASE TempHi OF
  1119.       10..15  : Network[i] := CHR(TempHi + 55);
  1120.       0..9    : Network[i] := CHR(TempHi + 48)
  1121.     ELSE        BEGIN
  1122.                   IPX_From_Addr := PARAMETER_ERROR;
  1123.                   EXIT;
  1124.                 END;
  1125.     END;
  1126.     i := i + 1;
  1127.     TempLo := Addr.Network[n] MOD 16;  (* Lo-Nibble                         *)
  1128.     CASE TempLo OF
  1129.       10..15  : Network[i] := CHR(TempLo + 55);
  1130.       0..9    : Network[i] := CHR(TempLo + 48)
  1131.     ELSE        BEGIN
  1132.                   IPX_From_Addr := PARAMETER_ERROR;
  1133.                   EXIT;
  1134.                 END;
  1135.     END;
  1136.     i := i + 1;
  1137.     n := n + 1;
  1138.   END;
  1139.   Network[0] := CHR(i);               (* Laenge Netzwerkadresse fuer String *)
  1140.  
  1141.  
  1142.   (* Node-Adresse konvertieren *)
  1143.   i := 1;
  1144.   n := 1;
  1145.   WHILE ( i <= (2 * NODE_LENGTH)) DO
  1146.   BEGIN
  1147.     TempHi := Addr.Node[n] DIV 16;     (* Hi-Nibble                         *)
  1148.     CASE TempHi OF
  1149.       10..15  : Node[i] := CHR(TempHi + 55);
  1150.       0..9    : Node[i] := CHR(TempHi + 48)
  1151.     ELSE        BEGIN
  1152.                   IPX_From_Addr := PARAMETER_ERROR;
  1153.                   EXIT;
  1154.                 END;
  1155.     END;
  1156.     i := i + 1;
  1157.     TempLo := Addr.Node[n] MOD 16;     (* Lo-Nibble                         *)
  1158.     CASE TempLo OF
  1159.       10..15  : Node[i] := CHR(TempLo + 55);
  1160.       0..9    : Node[i] := CHR(TempLo + 48)
  1161.     ELSE        BEGIN
  1162.                   IPX_From_Addr := PARAMETER_ERROR;
  1163.                   EXIT;
  1164.                 END;
  1165.     END;
  1166.     i := i + 1;
  1167.     n := n + 1;
  1168.   END;
  1169.   Node[0] := CHR(i - 1);              (* Laenge Knotenadr. fuer String     *)
  1170.  
  1171.  
  1172.   (* Sockelnummer konvertieren *)
  1173.   STR (Addr.Socket,Socket);
  1174.  
  1175.   IPX_From_Addr := SUCCESS;
  1176. END;
  1177.  
  1178. END.